package es.wtestgen.action.alumno;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.sql.Date;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.GregorianCalendar;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;
import org.apache.struts.action.ActionRedirect;

import com.lowagie.text.Document;

import es.wtestgen.action.WTestGenAction;
import es.wtestgen.bean.alumno.TareaForm;
import es.wtestgen.bean.profesor.AlumnoForm;
import es.wtestgen.bean.profesor.ExamenForm;
import es.wtestgen.bean.profesor.ExamenResueltoForm;
import es.wtestgen.domain.Alumno;
import es.wtestgen.domain.Asignatura;
import es.wtestgen.domain.Examen;
import es.wtestgen.domain.ExamenResuelto;
import es.wtestgen.domain.Pregunta;
import es.wtestgen.domain.Respuesta;
import es.wtestgen.services.AlumnoDAO;
import es.wtestgen.services.AsignaturaDAO;
import es.wtestgen.services.ExamenDAO;
import es.wtestgen.services.ExamenResueltoDAO;
import es.wtestgen.services.RespuestaDAO;
import es.wtestgen.util.GeneradorPdf;

public class MantenimientoTareasAction extends WTestGenAction {

	@Override
	public ActionForward _execute(ActionMapping mapping, ActionForm form,
			HttpServletRequest request, HttpServletResponse response) {
		log.info("_____Mantenimiento de alumnos:::::");	
		String accion = request.getParameter("accion");
		ActionForward forward = null;
		
		if(accion == null || accion.equals("")){
			forward = listar(mapping, form, request, response);
		}else if(accion.equals("seleccionarAsignatura")){
			
		}else if(accion.equals("resolver")){
			forward = resolver(mapping, form, request, response);			
		}else if(accion.equals("corregir")){
			forward = corregir(mapping, form, request, response);			
		}else if(accion.equals("verNotas")){
			forward = verNotas(mapping, form, request, response);
		}else if(accion.equals("notasAsignatura")){
			forward = notasAsignatura(mapping, form, request, response);			
		}else if(accion.equals("verNotasMedias")){
			forward = notasMediasAsignaturas(mapping, form, request, response);			
		}else if(accion.equals("pdf")){
			forward = pdf(mapping, form, request, response);			
		}

		return forward;
	}

	private ActionForward notasMediasAsignaturas(ActionMapping mapping,
			ActionForm form, HttpServletRequest request,
			HttpServletResponse response) {

		Alumno alumno = (Alumno)request.getSession().getAttribute("usuario");
		
		AlumnoForm alumnoForm = (AlumnoForm)form;		
		
		AsignaturaDAO asignaturaDao = new AsignaturaDAO();
		ExamenResueltoDAO examenResueltoDao = new ExamenResueltoDAO();
		ExamenDAO examenDao = new ExamenDAO();
		
		ExamenResuelto examenResuelto = new ExamenResuelto();
		
		List<Asignatura>asignaturas = new ArrayList<Asignatura>();
		List<Examen> examenes = new ArrayList<Examen>();
		List<ExamenResuelto> examenesResueltos = new ArrayList<ExamenResuelto>();		
		
		double notaMedia = 0.0d;
		int numExam = 0;
		
		asignaturas = asignaturaDao.findAsignaturasAlumno(alumno);

		Map<String, String> notasMedias = new HashMap<String, String>();
		Map<String, Integer> numExamenesPropuestos = new HashMap<String, Integer>();
		Map<String, Integer> numExamenesResueltos = new HashMap<String, Integer>();
		
		for (Iterator iterator = asignaturas.iterator(); iterator.hasNext();) {
			Asignatura asignatura = (Asignatura)iterator.next();
			
			examenes = (List<Examen>)examenDao.findByAsignatura(asignatura);
			
			/*
			 * examenes propuestos para la asignatura
			 */
			numExamenesPropuestos.put(String.valueOf(asignatura.getCodAsig()), examenes.size());
			
			if(examenes.size() > 0){
				for (Iterator iterator2 = examenes.iterator(); iterator2.hasNext();) {
					Examen examen = (Examen) iterator2.next();			
					if(examenResueltoDao.findByExamenYAlumno(examen, alumno).size() > 0){
						examenResuelto = (ExamenResuelto)examenResueltoDao.findByExamenYAlumno(examen,alumno).get(0);
						examenesResueltos.add(examenResuelto);
						notaMedia = examenResuelto.getNota() + notaMedia;
						numExam++;
					}			
				}
			}
			/*
			 * examenes resueltos de la asignatura
			 */
			numExamenesResueltos.put(String.valueOf(asignatura.getCodAsig()), numExam);
			
			if(numExam > 0){
				notaMedia = (double)Math.round((notaMedia / numExam)*100)/100;
				notasMedias.put(String.valueOf(asignatura.getCodAsig()), String.valueOf((notaMedia)));
				numExam = 0;
				notaMedia = 0.0d;
			}else{
				notasMedias.put(String.valueOf(asignatura.getCodAsig()), "0.0");				
			}
		}
		
		alumnoForm.setAsignaturas(asignaturas);	
		
		request.getSession().setAttribute("asignaturas", asignaturas);
		request.getSession().setAttribute("notasMedias", notasMedias);
		request.getSession().setAttribute("numExamenesResueltos", numExamenesResueltos);
		request.getSession().setAttribute("numExamenesPropuestos", numExamenesPropuestos);
		
		return mapping.findForward("notasMediasAsignaturas");
		
	}

	private ActionForward notasAsignatura(ActionMapping mapping,
			ActionForm form, HttpServletRequest request,
			HttpServletResponse response) {

		Alumno alumno = (Alumno)request.getSession().getAttribute("usuario");
		
		AlumnoForm alumnoForm = (AlumnoForm)form;
		
		double notaMedia = 0.0d;
		int numExam = 0;
		
		ExamenDAO examenDao = new ExamenDAO();
		ExamenResueltoDAO examenResueltoDao = new ExamenResueltoDAO();
		AsignaturaDAO asignaturaDao = new AsignaturaDAO();
		
		ExamenResuelto examenResuelto = new ExamenResuelto();
		
		Asignatura asignatura =  (Asignatura)asignaturaDao.findById(alumnoForm.getCodAsig()).get(0);
		
		List<Examen> examenes = (List<Examen>)examenDao.findByAsignatura(asignatura);
		
		List<ExamenResuelto> examenesResueltos = new ArrayList<ExamenResuelto>();		
		
		if(examenes != null && examenes.size() > 0){
			for (Iterator iterator = examenes.iterator(); iterator.hasNext();) {
				Examen examen = (Examen) iterator.next();			
				if(examenResueltoDao.findByExamenYAlumno(examen,alumno).size() > 0){
					examenResuelto = (ExamenResuelto)examenResueltoDao.findByExamenYAlumno(examen,alumno).get(0);
					examenesResueltos.add(examenResuelto);
					notaMedia = examenResuelto.getNota() + notaMedia;
					numExam++;
				}			
			}		
			
			if(numExam > 0){
				notaMedia = (double)Math.round((notaMedia / numExam)*100)/100;
			}
			
			alumnoForm.setExamenesResueltos(examenesResueltos);			
		}
		
		request.getSession().setAttribute("examenesResueltos", examenesResueltos);		
		request.getSession().setAttribute("notaMedia", notaMedia);		
		request.getSession().setAttribute("asignatura", asignatura);		
		
		
		return mapping.findForward("verNotaAsignatura");
	}

	private ActionForward verNotas(ActionMapping mapping, ActionForm form,
			HttpServletRequest request, HttpServletResponse response) {

		Alumno alumno = (Alumno)request.getSession().getAttribute("usuario");
		
		AlumnoForm alumnoForm = (AlumnoForm)form;
		
		AsignaturaDAO asignaturaDao = new AsignaturaDAO();
		
		List<Asignatura>asignaturas = new ArrayList<Asignatura>();
		
		asignaturas = asignaturaDao.findAsignaturasAlumno(alumno);
		
		alumnoForm.setAsignaturas(asignaturas);	
		
		request.getSession().setAttribute("asignaturas", asignaturas);
		
		return mapping.findForward("asignaturasAlumno");
	}

	private ActionForward resolver(ActionMapping mapping, ActionForm form,
			HttpServletRequest request, HttpServletResponse response) {

		String codExam = (String)request.getParameter("codExam");
		
		ExamenDAO examenDao = new ExamenDAO();
		AsignaturaDAO asignaturaDao = new AsignaturaDAO();
		
		Asignatura asignatura = new Asignatura();
		
		Examen examen = (Examen)examenDao.findById(codExam).get(0);
		
		List<Pregunta> preguntasExamen = new ArrayList<Pregunta>();
		List<Respuesta> respuestasExamen = new ArrayList<Respuesta>();
		
		preguntasExamen = examenDao.getPreguntas(examen);
		respuestasExamen = examenDao.getRespuestas(examen);
		
		examen.setPreguntas(new HashSet<Pregunta>(preguntasExamen));
		examen.setRespuestas(new HashSet<Respuesta>(respuestasExamen));
		
		asignatura = (Asignatura)asignaturaDao.findById(String.valueOf(examen.getAsignatura().getCodAsig())).get(0);
		
		request.getSession().setAttribute("asignatura", asignatura);		
		
		request.getSession().setAttribute("examen", examen);
		request.getSession().setAttribute("preguntasExamen", examen.getPreguntas());
		request.getSession().setAttribute("respuestasPreguntaExamen", examen.getRespuestas());	
		
		return mapping.findForward("resolverExamen");
		
		
	}

	private ActionForward listar(ActionMapping mapping, ActionForm form,
			HttpServletRequest request, HttpServletResponse response) {

		TareaForm tareaForm = (TareaForm)form;
		
		Alumno alumno = (Alumno)request.getSession().getAttribute("usuario");
		
		AlumnoDAO alumnoDao = new AlumnoDAO();
		ExamenDAO examenDao = new ExamenDAO();		
		ExamenResueltoDAO examenResueltoDao = new ExamenResueltoDAO();		
		AsignaturaDAO asignaturaDao = new AsignaturaDAO();
		
		List<Asignatura> asignaturas = (List)asignaturaDao.findAsignaturasAlumno(alumno);
		List<Examen> examenes = new ArrayList<Examen>();
		List<Examen> examenesPendientes = new ArrayList<Examen>();
		
		for (Iterator iterator = asignaturas.iterator(); iterator.hasNext();) {
			Asignatura asignatura = (Asignatura) iterator.next();
			examenes = examenDao.findByAsignatura(asignatura);
			for (Iterator iterator2 = examenes.iterator(); iterator2
					.hasNext();) {
				Examen examen = (Examen) iterator2.next();
				if(examen.isPublicado()){
					if(examenResueltoDao.findByExamenYAlumno(examen,alumno).size() <= 0)
						examenesPendientes.add(examen);
				}				
			}			
		}
		
		tareaForm.setExamenesPendientes(examenesPendientes);
		
		return mapping.findForward("entradaAlumnos");		
	}
	
	private ActionForward examenCorregido(ActionMapping mapping, ActionForm form,
			HttpServletRequest request, HttpServletResponse response) {
		
		ExamenResueltoForm examenResueltoForm = (ExamenResueltoForm)form;
		
		Alumno alumno = (Alumno)request.getSession().getAttribute("usuario");
				
		return mapping.findForward("examenResueltoCorregido");		
	}
	
	private ActionForward corregir(ActionMapping mapping, ActionForm form,
			HttpServletRequest request, HttpServletResponse response) {
		
		ExamenResueltoForm examenResueltoForm = (ExamenResueltoForm)form;
		
		/*
		 * Para recuperar el alumno
		 */
		Alumno alumno = (Alumno)request.getSession().getAttribute("usuario");
		
		//Enumeration e = request.getParameterNames();		
		
		String codExam = (String)request.getParameter("codExam");
		Set<Respuesta> respuestasResu = new HashSet<Respuesta>();
		double nota = 0d;
		
		Examen examen = new Examen();
		Respuesta respuesta = new Respuesta();
		
		ExamenDAO examenDao = new ExamenDAO();
		RespuestaDAO respuestaDao = new RespuestaDAO();
		ExamenResueltoDAO examenResueltoDao = new ExamenResueltoDAO();
		
		examen = (Examen)examenDao.findById(codExam).get(0);
		
		Set<Pregunta> preguntas = examen.getPreguntas();
		Map<String, String> preguntasRespuesta = new HashMap<String, String>();
				
		for (Iterator iterator = preguntas.iterator(); iterator.hasNext();) {
			Pregunta pregunta = (Pregunta) iterator.next();
			
			String codPregunta = "codPreg"+String.valueOf(pregunta.getCodPreg());
			String codResp = (String)request.getParameter(codPregunta);
			
			/*
			 *	Si hemos dejado en blanco alguna respuesta no la tratamos 
			 */
			if(codResp != null){
				respuesta = (Respuesta)respuestaDao.findById(codResp).get(0);
				
				if(respuesta.isEsCorrecta()){
					nota = nota + (10d/examen.getNumPreg());
				}				
				respuestasResu.add(respuesta);
			}
		}
		
		ExamenResuelto examenResuelto = new ExamenResuelto();
		
		/*
		 * Establecemos la fecha actual como fecha de resolucion de examen
		 */
		
		GregorianCalendar calendar = new GregorianCalendar();
		long milisegundos = calendar.getTimeInMillis();
		Date date = new Date(milisegundos);
		int anyo = date.getYear()+1900;
		int mes = date.getMonth()+1;
		int dia = date.getDate();
		String d = "";
		String m = "";
		if(dia > 0 && dia < 10){
			d = "0" + String.valueOf(dia);
		}else{
			d = String.valueOf(dia);
		}
		if(mes > 0 && mes < 10){
			m = "0" + String.valueOf(mes);				
		}else{
			m = String.valueOf(mes);
		}
		String fechaExamResu = d + "/" + m + "/" + String.valueOf(anyo);
		
		examenResuelto.setFechaExamResu(fechaExamResu);
		examenResuelto.setAlumno(alumno);
		examenResuelto.setExamen(examen);
		examenResuelto.setRespuestasResu(respuestasResu);
		nota = (double)Math.round(nota*100)/100;
		examenResuelto.setNota(nota);
		
		if(examenResueltoForm.getCodExamResu() != null && !examenResueltoForm.getCodExamResu().equals("") && !examenResueltoForm.getCodExamResu().equals("0")){
			int id = Integer.parseInt(examenResueltoForm.getCodExamResu());
			examenResuelto.setCodExamResu(id);
		}else{
			examenResuelto.setCodExamResu(-1);
		}
		
		if(examenResueltoDao.guardarExamenResuelto(examenResuelto)){
			examenResueltoForm.setCodAlum(examenResuelto.getAlumno().getCodAlum());
			examenResueltoForm.setCodExam(examenResuelto.getExamen().getCodExam());
			examenResueltoForm.setFechaExamResu(examenResuelto.getFechaExamResu());
			examenResueltoForm.setNota(examenResuelto.getNota());
			examenResueltoForm.setRespuestas(examenResuelto.getRespuestasResu());		
			
			return examenCorregido(mapping, examenResueltoForm, request, response);
		}else{
			return mapping.findForward("error");			
		}
		
	}
	
	
	private ActionForward pdf(ActionMapping mapping, ActionForm form,
			HttpServletRequest request, HttpServletResponse response) {
		
		TareaForm tareaForm = (TareaForm)form;
		
		String codExam = (String)request.getParameter("codExam");
		
		ExamenDAO examenDao = new ExamenDAO();
		
		Examen examen = new Examen();
				
		List<Pregunta> preguntasExamen = new ArrayList<Pregunta>();
		List<Respuesta> respuestasExamen = new ArrayList<Respuesta>();
		
		Document document = new Document();
		
		examen = (Examen)examenDao.findById(codExam).get(0);
		
		preguntasExamen = examenDao.getPreguntas(examen);
		respuestasExamen = examenDao.getRespuestas(examen);
		
		examen.setPreguntas(new HashSet<Pregunta>(preguntasExamen));
		examen.setRespuestas(new HashSet<Respuesta>(respuestasExamen));
		
		ByteArrayOutputStream baos = new ByteArrayOutputStream();
		try{
			GeneradorPdf.generarExamenPdf(request,response, examen,document, baos);
			
			response.setContentType ("application/pdf");
			//set the header and also the Name by which user will be prompted to save
			response.setHeader ("Content-Disposition", "attachment;filename=\"Examen-"+examen.getAsignatura().getNombreAsig()+"("+examen.getFechaExam()+").pdf\"");
			
			ServletOutputStream out = response.getOutputStream();
			baos.writeTo(out);
			out.flush();
		}catch (IOException e) {
			log.info("_____Error: no se ha podido generar el documento en Pdf", e);
			e.printStackTrace();
		}
		
		return null;
	}
	

}
